unique_ptr< _Ty[], _Dx > Class Template Reference

Inheritance diagram for unique_ptr< _Ty[], _Dx >:

Public Types
typedef unique_ptr< _Ty[], _Dx >	_Myt
typedef _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty[]>, _Dx >::value >	_Mybase
typedef _Mybase::pointer	pointer
typedef _Ty	element_type
typedef _Dx	deleter_type

Public Member Functions
	unique_ptr () _NOEXCEPT
	unique_ptr (pointer _Ptr) _NOEXCEPT
	unique_ptr (pointer _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type _Dt) _NOEXCEPT
	unique_ptr (pointer _Ptr, typename remove_reference< _Dx >::type &&_Dt) _NOEXCEPT
	unique_ptr (unique_ptr &&_Right) _NOEXCEPT
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
	unique_ptr (nullptr_t) _NOEXCEPT
_Myt &	operator= (nullptr_t) _NOEXCEPT
void	reset (nullptr_t) _NOEXCEPT
void	swap (_Myt &_Right) _NOEXCEPT
	~unique_ptr () _NOEXCEPT
add_reference< _Ty >::type	operator[] (size_t _Idx) const
pointer	get () const _NOEXCEPT
	operator bool () const _NOEXCEPT
pointer	release () _NOEXCEPT
void	reset (pointer _Ptr=pointer()) _NOEXCEPT
template<class _Ptr2 >
	unique_ptr (_Ptr2)=delete
template<class _Ptr2 , class _Dx2 >
	unique_ptr (_Ptr2, _Dx2)=delete
	unique_ptr (const _Myt &)=delete
_Myt &	operator= (const _Myt &)=delete
template<class _Ptr2 >
void	reset (_Ptr2)=delete

Private Member Functions
void	_Delete ()
Private Member Functions inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty[]>, _Dx >::value >
	_Unique_ptr_base (pointer _Ptr, _Dx _Dt)
	_Unique_ptr_base (pointer _Ptr)
	_Unique_ptr_base (_Ptr2 _Ptr, _Dx2 _Dt)
	_Unique_ptr_base (_Ptr2 _Ptr)
_Dx_noref &	get_deleter ()
const _Dx_noref &	get_deleter () const

Additional Inherited Members
Private Types inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty[]>, _Dx >::value >
typedef remove_reference< _Dx >::type	_Dx_noref
typedef _Get_deleter_pointer_type< _Ty, _Dx_noref >::type	pointer
Private Attributes inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty[]>, _Dx >::value >
pointer	_Myptr
_Dx	_Mydel

Member Typedef Documentation

template<class _Ty , class _Dx >

typedef _Unique_ptr_base<_Ty, _Dx, is_empty<_Dx>::value || is_same<default_delete<_Ty[]>, _Dx>::value> unique_ptr< _Ty[], _Dx >::_Mybase

template<class _Ty , class _Dx >

typedef unique_ptr<_Ty[], _Dx> unique_ptr< _Ty[], _Dx >::_Myt

template<class _Ty , class _Dx >

typedef _Dx unique_ptr< _Ty[], _Dx >::deleter_type

template<class _Ty , class _Dx >

typedef _Ty unique_ptr< _Ty[], _Dx >::element_type

template<class _Ty , class _Dx >

typedef _Mybase::pointer unique_ptr< _Ty[], _Dx >::pointer

Constructor & Destructor Documentation

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( )

inline

        : _Mybase(pointer())
        {   // default construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( pointer  _Ptr )

inlineexplicit

        : _Mybase(_Ptr)
        {   // construct with pointer
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( pointer  _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type  _Dt  )

inline

        : _Mybase(_Ptr, _Dt)
        {   // construct with pointer and (maybe const) deleter&
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( pointer  _Ptr, typename remove_reference< _Dx >::type &&  _Dt  )

inline

        : _Mybase(_Ptr, _STD move(_Dt))
        {   // construct by moving deleter
        static_assert(!is_reference<_Dx>::value,
            "unique_ptr constructed with reference to rvalue deleter");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( unique_ptr< _Ty[], _Dx > &&  _Right )

inline

        : _Mybase(_Right.release(),
            _STD forward<_Dx>(_Right.get_deleter()))
        {   // construct by moving _Right
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( nullptr_t  )

inline

        : _Mybase(pointer())
        {   // null pointer construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::~unique_ptr ( )

inline

        {   // destroy the object
        _Delete();
        }

template<class _Ty , class _Dx >

template<class _Ptr2 >

unique_ptr< _Ty[], _Dx >::unique_ptr ( _Ptr2  )

explicitdelete

template<class _Ty , class _Dx >

template<class _Ptr2 , class _Dx2 >

unique_ptr< _Ty[], _Dx >::unique_ptr ( _Ptr2  , _Dx2    )

delete

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( const _Myt &  )

delete

Member Function Documentation

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::_Delete ( )

inlineprivate

        {   // delete the pointer
        if (this->_Myptr != pointer())
            this->get_deleter()(this->_Myptr);
        }

template<class _Ty , class _Dx >

pointer unique_ptr< _Ty[], _Dx >::get ( ) const

inline

        {   // return pointer to object
        return (this->_Myptr);
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::operator bool ( ) const

inlineexplicit

        {   // test for non-null pointer
        return (this->_Myptr != pointer());
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, do the swap
            reset(_Right.release());
            this->get_deleter() = _STD move(_Right.get_deleter());
            }
        return (*this);
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( nullptr_t  )

inline

        {   // assign a null pointer
        reset();
        return (*this);
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( const _Myt &  )

delete

template<class _Ty , class _Dx >

add_reference<_Ty>::type unique_ptr< _Ty[], _Dx >::operator[] ( size_t  _Idx ) const

inline

        {   // return reference to object
        return (this->_Myptr[_Idx]);
        }

template<class _Ty , class _Dx >

pointer unique_ptr< _Ty[], _Dx >::release ( )

inline

        {   // yield ownership of pointer
        pointer _Ans = this->_Myptr;
        this->_Myptr = pointer();
        return (_Ans);
        }

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::reset ( nullptr_t  )

inline

        {   // establish new null pointer
        reset();
        }

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::reset ( pointer  _Ptr = pointer() )

inline

        {   // establish new pointer
        _Delete();
        this->_Myptr = _Ptr;
        }

template<class _Ty , class _Dx >

template<class _Ptr2 >

void unique_ptr< _Ty[], _Dx >::reset ( _Ptr2  )

delete

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::swap ( _Myt &  _Right )

inline

        {   // swap elements
        _Swap_adl(this->_Myptr, _Right._Myptr);
        _Swap_adl(this->get_deleter(), _Right.get_deleter());
        }

---

The documentation for this class was generated from the following file:

• VS2013/inc/memory